home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok58.lha / NPrint / txt / arp.def next >
Text File  |  1993-08-15  |  26KB  |  612 lines
  1. (*---------------------------------------------------------------------------
  2.   :Program.    ARP.def
  3.   :Author.     M2 implementation by Fridtjof Siebert
  4.   :Address.    Nobileweg 67, D-7-Stgt-40
  5.   :Shortcut.   [fbs]
  6.   :Version.    1.01 (ARP version 39)
  7.   :Date.       10-11-90
  8.   :Copyright.  PD
  9.   :Language.   Modula-II
  10.   :Translator. M2Amiga v3.3d
  11.   :History.    30-Dec-88 v0.1 created for ARP1.0          [fbs]
  12.   :History.    14-Jan-88 v1.0 implementation for ARP1.1   [fbs]
  13.   :History     10-11-90  v1.01 implement a part for ARP1.3 Oliver Schersand
  14.   :Contents.   Library Modul for arp.library.
  15.   :Remark.     Contact me if your find errors. I wasn't able to all of it!
  16.   :Remark.     Thanx to Martin Taillefer for his Benchmark ARP-code
  17.  
  18.   :Bugs.     Attention  version v1.01 is wrong. I don`t changed all
  19.   :Bugs      parts of ARP1.1. Please don`t use this version.
  20. ---------------------------------------------------------------------------*)
  21.  
  22. DEFINITION MODULE ARP {"arp.library",39};
  23.  
  24. FROM SYSTEM    IMPORT ADDRESS, LONGSET, SHIFT, BPTR;
  25. FROM Dos       IMPORT DosLibrary, FileInfoBlock, FileInfoBlockPtr,
  26.                       FileHandlePtr, FileLockPtr, ProcessPtr, DosPacketPtr,
  27.                       DatePtr, BSTR, DeviceList, Date, InfoDataPtr;
  28. FROM Exec      IMPORT UByte, Byte, MinList, MinNode, MsgPortPtr, MemReqSet,
  29.                       SignalSemaphore, TaskPtr, Node, Library, Message;
  30. FROM Graphics  IMPORT GfxBasePtr;
  31. FROM Intuition IMPORT IntuitionBase, WindowPtr;
  32.  
  33. (*------  Some Pointers:  ------*)
  34.  
  35. TYPE
  36.   STRPTR = ADDRESS;         (* POINTER TO ARRAY OF CHAR, used for clarity *)
  37.   DeviceListPtr = POINTER TO DeviceList; (* can't be imported from DOS *)
  38.  
  39. (*------  Types needed for template:  ------*)
  40.  
  41.   StrArrayPtr = POINTER TO ARRAY [0..1000] OF STRPTR;
  42.   (* StrArrayPtr is a pointer to an array of pointers to strings *)
  43.  
  44.   WBArgPtr = POINTER TO WBArg;
  45.   WBArg = RECORD
  46.     lock: FileLockPtr;      (* a lock descriptor *)
  47.     str : STRPTR;           (* a string relative to that lock *)
  48.   END;
  49.  
  50.   CLIArgPtr = POINTER TO CLIArg;
  51.   CLIArg = RECORD
  52.     CASE : CARDINAL OF
  53.       0: bool: BOOLEAN;     |
  54.       1: long: LONGINT;     |
  55.       2: str: STRPTR;       |
  56.       3: array: StrArrayPtr;|
  57.     END;
  58.   END;
  59.  
  60. (*------  Library Stuff:  ------*)
  61.  
  62. (* use Wildcards/escapes like rest of world or like current dos: *)
  63.  
  64.   ArpFlags = (wildWorld,wildBCPL);
  65.   ArpFlagSet = SET OF ArpFlags;
  66.  
  67.   EnvBasePtr = POINTER TO EnvBase; (* Identical to EnvLibPtr *)
  68.  
  69.   ArpBasePtr = POINTER TO ArpBase;
  70.   ArpBase = RECORD
  71.     libNode: Library;         (* Standard library node *)
  72.     segList: BPTR;            (* Pointer to segment list of loaded library *)
  73.     flags: Byte;              (* Not used, yet! *)
  74.     escChar: CHAR;            (* Character used for ESCaping *)
  75.     abreserved: LONGCARD;     (* ArpLib's use only!! *)
  76.     envBase: EnvBasePtr;       (* ptr to environment                   *)
  77.     dosBase: POINTER TO DosLibrary;
  78.     gfxBase: GfxBasePtr;
  79.     intuiBase: POINTER TO IntuitionBase;
  80.     resLists: MinList;
  81.     residentPrgList: ADDRESS; (* Resident Programs.   *)
  82.     resPrgProtection: SignalSemaphore; (* Protection for above *)
  83.   END;
  84.  
  85.   EnvBase = RECORD        (* EnvBase *)
  86.     libNode: Library;
  87.     space: ADDRESS;
  88.     size: LONGCARD;
  89.     arpBase: ArpBasePtr;
  90.   END;
  91.  
  92. (* library constants: *)
  93.  
  94. CONST
  95.   arpname = 'arp.library';
  96.   arpversion = 39;
  97.  
  98. (*------  ARP Alert Numbers:  ------*)
  99.  
  100.   aoArpLib = 8036H; (* Alert Object *)
  101.  
  102.   (* Alerts ARP can return *)
  103.   anArpLib       = 03600000H;
  104.   anArpNoMem     = 03610000H;    (* ArpLibrary out of memory              *)
  105.   anArpInputMem  = 03610002H;    (* No memory for input buffer            *)
  106.   anArpNoMakeEnv = 83610003H;    (* No memory for Environment library     *)
  107.  
  108.   anArpNoDOS     = 83630001H;    (* Can't Open DOS library                *)
  109.   anArpNoGfx     = 83630002H;    (* Can't open Graphics library           *)
  110.   anArpNoIntuit  = 83630003H;    (* Can't open Intuition library          *)
  111.   anBadPackBlues = 83640000H;    (* Bad packet returned to SendPacket()   *)
  112.   anZombie       = 83600003H;    (* Zombie roaming around system          *)
  113.  
  114.   anArpScattered = 83600002H;    (* Scatter loading not allowed           *)
  115.  
  116. (*------  Return codes from Assign() and CompareLock(): ------*)
  117.  
  118. TYPE
  119.   AssignRes = (assignOK,assignNoDev,assignFatal,assignCancel);
  120.   LockComp  = (equal,equalVolume,difVol1,difVol2);
  121.  
  122. CONST
  123.   maxInputBuf = 256;  (* size of buffer needed for ReadLine() *)
  124.  
  125. (*------  Input structure for File Requester  ------*)
  126.  
  127.   fChars = 32;
  128.   dSize  = 33;
  129.   longdSize = 254;
  130.   longfSize = 126;
  131.  
  132.   frFirstGadg = 7680H;
  133.  
  134. TYPE
  135.   FileName = ARRAY[0..fChars] OF CHAR;
  136.   DirName  = ARRAY[0..dSize] OF CHAR;
  137.   FileNamePtr = POINTER TO FileName;
  138.   DirNamePtr  = POINTER TO DirName;
  139.  
  140.   FileReqFlags = (listFunc,gEventFunc,addGadFunc,newWindFunc,newIDCMP,
  141.                   doColor,doMsgFunc,doWildFunc);
  142.   FileReqFlagSet = SET OF FileReqFlags;
  143.  
  144.   FileReqFlag2s = (longPath);
  145.   FileReqFlag2Set = SET OF FileReqFlag2s;
  146.  
  147.   FileReqFunc = PROCEDURE(LONGCARD,ADDRESS): LONGINT; (* Please Test it *)
  148.  
  149.   FileRequesterPtr = POINTER TO FileRequester;
  150.   FileRequester = RECORD
  151.     hail      : STRPTR;                (* Hailing text                     *)
  152.     file      : FileNamePtr;           (* Filename array (FCHARS+1)        *)
  153.     dir       : DirNamePtr;            (* Directory array (DSIZE+1)        *)
  154.     window    : WindowPtr;             (* Window requesting or NULL        *)
  155.     funcFlags : FileReqFlagSet;        (* Control. See above.              *)
  156.     flags2    : FileReqFlag2Set;       (* Set this to 0                    *)
  157.     function  : FileReqFunc;           (* Your function, see btdef's       *)
  158.     leftEdge,
  159.     topEddge  : CARDINAL;
  160.   END;
  161.  
  162. (*------  Structures and constants used by the wildcard routines  ------*)
  163.  
  164. CONST
  165.   pAny        =  80H;
  166.   pSingle     =  81H;
  167.   pOrStart    =  82H;
  168.   pOrNext     =  83H;
  169.   pOrEnd      =  84H;
  170.   pTag        =  85H;
  171.   pTagEnd     =  86H;
  172.   pNotClass   =  87H;
  173.   pClass      =  88H;
  174.   pRepBeg     =  89H;
  175.   pReqEnd     =  8AH;
  176.  
  177.   complexBit  =  1; (* status bits *)
  178.   examineBit  =  2;
  179.  
  180.   errorBufferOverflow = 303; (* Returned by FindFirst() and FindNext(); *)
  181.   errorInternal =  999;
  182.   errorBreak    =  304;
  183.  
  184.   bufSize       =  200;
  185.   dosTRUE       =  0;
  186.   dosFALSE      =  -1;
  187.   maxFName      =  200;
  188.  
  189.   stdAnchorSize = 256;
  190.  
  191. TYPE
  192.   AChainPtr = POINTER TO AChain;
  193.   AnchorPathPtr = POINTER TO AnchorPath;
  194.   AnchorPathFlags = (doWild,itsWild,doDir,didDir,noMemErr,doDot);
  195.   AnchorPathFlagSet = SET OF AnchorPathFlags;
  196.  
  197.   AnchorPath = RECORD (* this is used by FindFirst/FindNext *)
  198.     base       : AChainPtr;
  199.     last       : AChainPtr;
  200.     breakBits  : LONGSET;
  201.     foundBreak : LONGSET;
  202.     flags      : AnchorPathFlagSet;
  203.     res        : Byte;
  204.     strLen     : INTEGER;
  205.     info       : FileInfoBlock;
  206.   END;
  207.  
  208.  AChainFlags = (patternBit,examinedBit,completed,allBit);
  209.  AChainFlagSet = SET OF AChainFlags;
  210.  
  211.   AChain = RECORD
  212.     child  : AChainPtr;
  213.     parent : AChainPtr;
  214.     lock   : FileLockPtr;
  215.     info   : FileInfoBlockPtr;
  216.     flags  : AChainFlagSet;
  217.     string : ARRAY [0..1] OF CHAR;             (* don't use it *)
  218.   END;
  219.  
  220.  
  221.  
  222. (*------  Structure used by AddDANode etc.:  ------*)
  223.  
  224.   DirEntryTypes   = (devices,diskonly,volumes,dirs,det4,det5);
  225.   DirEntryTypeSet = SET OF DirEntryTypes;
  226.  
  227.   DirectoryEntryPtr = POINTER TO DirectoryEntry;
  228.   DirectoryEntry = RECORD
  229.     next: DirectoryEntryPtr;
  230.     type: DirEntryTypeSet;
  231.     flags: Byte;
  232.     name: ARRAY[0..255] OF CHAR; (* sorry, if your stuff gets longer! *)
  233.   END;
  234.  
  235. CONST
  236.   deFile      = DirEntryTypeSet{};          (*  0 *)
  237.   deDir       = DirEntryTypeSet{dirs};      (*  8 *)
  238.   deDevice    = DirEntryTypeSet{det4};      (* 16 *)
  239.   deVolume    = DirEntryTypeSet{dirs,det4}; (* 24 *)
  240.   deUnmounted = DirEntryTypeSet{det5};      (* 32 *)
  241.   deAssign    = DirEntryTypeSet{dirs,det5}; (* 40 *)
  242.  
  243. (*------  Resource Tracking:  ------*)
  244.  
  245.   trakAAMem   = 0;    (* Default generic (ArpAlloc) element  *)
  246.   trakLock    = 1;    (* File Lock                           *)
  247.   trakFile    = 2;    (* Opened File                         *)
  248.   trakWindow  = 3;    (* Window (see discussion)             *)
  249.   trakScreen  = 4;    (* Screen                              *)
  250.   trakLibrary = 5;    (* Opened library                      *)
  251.   trakDAMem   = 6;    (* Pointer to DosAllocMem block        *)
  252.   trakMemList = 7;    (* Exec Memlist                        *)
  253.   trakSegList = 8;    (* Program Segment List                *)
  254.   trakResList = 9;    (* ARP (nested) ResList                *)
  255.   trakMem     = 10;   (* Memory ptr/length                   *)
  256.   trakGeneric = 11;   (* Generic Element                     *)
  257.   trakDAList  = 12;   (* DAlist ( as used by file request )  *)
  258.   trakAnchor  = 13;   (* Anchor chain                        *)
  259.   trakMax     = 13;   (* Anything else is tossed.            *)
  260.  
  261. TYPE
  262.   ArpResListPtr = POINTER TO ArpResList;
  263.   ArpResList = RECORD
  264.     node: MinNode;      (* line these together *)
  265.     taskID: TaskPtr;
  266.     firstItem: MinList;
  267.     link: ArpResListPtr;   (* for temp removal from task rlist *)
  268.   END;
  269.  
  270.   TrackedResPtr = POINTER TO TrackedRes;
  271.   TrackedRes = RECORD
  272.     node: MinNode;
  273.     flags: Byte;
  274.     lock: Byte;
  275.     id: INTEGER;          (* see above *)
  276.     CASE :INTEGER OF
  277.       0:resource: ADDRESS;
  278.         value: LONGINT; |
  279.       1:function: PROC;
  280.         window2: WindowPtr; |
  281.     END;
  282.     user1 : ADDRESS;           (* A pointer you can use yourself    *)
  283.     user2 : LONGCARD;          (* A long you can use yourself       *)
  284.   END;
  285.  
  286.   DefaultTrackerPtr = POINTER TO DefaultTracker;
  287.   DefaultTracker = RECORD
  288.     CASE : CARDINAL OF
  289.       |0: resource : ADDRESS;   (* Whatever *)
  290.       |1: value    : LONGCARD;  (* For use during TrakGeneric    *)
  291.     END;
  292.     CASE : CARDINAL OF
  293.       |0: function : PROC;      (* Function to call for TrakGeneric *)
  294.       |1: window2  : WindowPtr; (* For TrakWindow                *)
  295.     END;
  296.     user1 : ADDRESS;           (* A pointer you can use yourself *)
  297.     user2 : LONGCARD;          (* A long you can use yourself    *)
  298.   END;
  299.  
  300. CONST
  301.   trbUnLink = 7;             (* free node bit *)
  302.   trbReloc  = 6;             (* This element may be relocated *)
  303.   trbMoved  = 5;             (* Item moved *)
  304.   trvUnLink = SHIFT(1,trbUnLink);
  305.   trvReloc  = SHIFT(1,trbReloc);
  306.  
  307. (*------  Errors returned by SyncRun() and ASyncRun():  ------*)
  308.  
  309.   prbSAVEIO      = 0;      (* Don't free/check file handles on exit *)
  310.   prbCLOSESPLAT  = 1;      (* Close Splat file, must request explicitly *)
  311.   prbNOCLI       = 2;      (* Don't create a CLI process *)
  312.   prbINTERACTIVE = 3;      (* This should be interactive *)
  313.   prbCODE        = 4;      (* Dangerous yet enticing *)
  314.   prbSTDIO       = 5;      (* Do the stdio thing, splat = CON:Filename *)
  315.  
  316.   prfSAVEIO      = SHIFT(1,0);
  317.   prfCLOSESPLAT  = SHIFT(1,1);
  318.   prfNOCLI       = SHIFT(1,2);
  319.   prfINTERACTIVE = SHIFT(1,3);
  320.   prfCODE        = SHIFT(1,4);
  321.   prfSTDIO       = SHIFT(1,5);
  322.  
  323.   prNoFile   = -1;   (* Could not LoadSeg() the file         *)
  324.   prNoMem    = -2;   (* No memory for something              *)
  325.   prNoCLI    = -3;   (* Caller must be CLI (SyncRun() only)  *)
  326.   prNoSlot   = -4;   (* No slot in TaskArray                 *)
  327.   prNoInput  = -5;   (* Could not open input file            *)
  328.   prNoOutput = -6;   (* Could not get output file            *)
  329.   prNoLock   = -7;   (* Could not get a lock                 *)
  330.   prArgErr   = -8;   (* Bad argument                         *)
  331.   prNoBCPL   = -9;   (* Bad program passed to ASyncRun()     *)
  332.   prBadLib   = -10;  (* Bad library version                  *)
  333.   prNoStdIO  = -11;  (* Couldn't get stdio handles.          *)
  334.  
  335.   errorNotCLI   = 400;  (* Program/function needs to be cli      *)
  336.   errorBadMagic = 401;  (* Invalid magic number for resident prg *)
  337.  
  338.   noCMD = "\n";
  339.  
  340. (*------  ZombieMsg (sent back on request by exiting process):  ------*)
  341.  
  342. TYPE
  343.   ZombieMsgPtr = POINTER TO ZombieMsg;
  344.   ZombieMsg = RECORD
  345.     message: Message;          (* You must init ReplyPort!!!!! *)
  346.     taskNum: LONGCARD;         (* Task ID                      *)
  347.     returnCode: LONGCARD;      (* Process's return code        *)
  348.     result2: LONGCARD;         (* System return code           *)
  349.     exitTime: Date;            (* Date stamp at time of exit   *)
  350.     userInfo: LONGCARD;        (* For whatever you wish.       *)
  351.   END;
  352.  
  353.   PCBFlags = (saveIO,           (* Don't release/check file handles         *)
  354.               closeSplat,       (* Close Splat file                         *)
  355.               noCLI,            (* Don't create a CLI process               *)
  356.               interactive,      (* This should be interactive, CLI's only   *)
  357.               code,             (* Actual code ADDRESS, be CAREFUL!         *)
  358.               stdIO);           (* Do the StdIO thing, Splat = CON:FileName *)
  359.   PCBFlagSet = SET OF PCBFlags;
  360.  
  361.   ProcessCtrlBlkPtr = POINTER TO PCB;
  362.   ProcessCtrlBlk = RECORD
  363.     stackSize: LONGCARD;         (* Stack for new process   *)
  364.     pri: Byte;                   (* Priority of new process *)
  365.     control: PCBFlagSet;         (* Control bits            *)
  366.     trapCode: ADDRESS;           (* Optional Trap Code      *)
  367.     input,output: FileHandlePtr; (* Optional stdin, stdout  *)
  368.     CASE : CARDINAL OF
  369.       0: splatFile: FileHandlePtr; | (* File to use for Open("*") *)
  370.       1: conName: ADDRESS;    |   (* or CON: filename             *)
  371.       2: console: ADDRESS;    |   (* Yippee for record variants!  *)
  372.     END;
  373.     loadedCode: ADDRESS;     (* If not null, will not load/unload code  *)
  374.     lastGasp: ZombieMsgPtr;  (* ReplyMsg() to be filled in by exit      *)
  375.     wbProcess: MsgPortPtr;   (* Valid when noerror and prbNOCLI is set *)
  376.   END;
  377.  
  378. (*------  Resident Program support:  ------*)
  379.  
  380. TYPE
  381.   ResidentPrgNodePtr = POINTER TO ResidentProgramNode;
  382.   ResidentPrgNode = RECORD
  383.     next: ResidentPrgNodePtr;
  384.     usage: LONGINT;  (* How many programs are currently using the code *)
  385.     checkSum: LONGCARD;
  386.     segment: BPTR;               (* Actual LoadSeg'ed segments         *)
  387.     name: ARRAY[0..255] OF CHAR; (* the names mem is allocated as needed !!! *)
  388.   END;
  389.  
  390.   ResidentProgramTag = RECORD
  391.     nextSeg: BPTR;       (* Provided by DOS at LoadSeg time.  *)
  392.     bra: CARDINAL;       (* Short branch to executable        *)
  393.     magic: CARDINAL;     (* Resident majik value              *)
  394.     stackSize: LONGCARD; (* min stack for this process        *)
  395.     dataSize: LONGCARD;  (* Data size to allocate if resident *)
  396.   END;
  397.  
  398.   ProcessMemoryPtr = POINTER TO ProcessMemory;
  399.   ProcessMemory = RECORD
  400.     node: Node;
  401.     num: CARDINAL; (* number of entries, 1 if no data 2 if data *)
  402.     stack: ADDRESS;
  403.     stackSize: LONGCARD;
  404.     data: ADDRESS;  (* pointer to data *)
  405.     dataSize: LONGCARD;
  406.   END;
  407.  
  408. CONST
  409.   residentMagic = 4AFCH;  (* same as RTC_MATCHWORD (trapf) *)
  410.   pMemName = "ARP_MEM";
  411.  
  412. (*------  String/Date Structures:  ------*)
  413.  
  414. TYPE
  415.   DateType = (amigaDOS,       (* dd-mmm-yy *)
  416.               international,  (* yy-mm-dd  *)
  417.               usa,            (* mm-dd-yy  *)
  418.               european);      (* dd-mm-yy  *)
  419.  
  420.   DateTimeFlags = (subst,    (* Substitute string such as "Today", ... *)
  421.                    future);  (* Monday, Tuesday ... refer to next week *)
  422.   DateTimeFlagSet = SET OF DateTimeFlags;
  423.  
  424.   DateTimePtr = POINTER TO DateTime;
  425.   DateTime = RECORD
  426.     stamp: Date;
  427.     format: DateType;
  428.     flags: DateTimeFlagSet;
  429.     day: STRPTR;
  430.     date: STRPTR;
  431.     time: STRPTR;
  432.   END;
  433.  
  434. CONST
  435.  lenDateString = 10H;
  436.  
  437. (*------  Procedures:  ------*)
  438.  
  439. PROCEDURE Open(name{1}       : STRPTR;
  440.                accessMode{2} : LONGINT): FileHandlePtr;           CODE -30;
  441. PROCEDURE Close(file{1}: FileHandlePtr);                         CODE -36;
  442. PROCEDURE Read(file{1}: FileHandlePtr;
  443.                buffer{2}: ADDRESS;
  444.                length{3}: LONGINT): LONGINT;                     CODE -42;
  445. PROCEDURE Write(file{1}: FileHandlePtr;
  446.                 buffer{2}: ADDRESS;
  447.                 length{3}: LONGINT): LONGINT;                    CODE -48;
  448. PROCEDURE Input(): FileHandlePtr;                                CODE -54;
  449. PROCEDURE Output(): FileHandlePtr;                               CODE -60;
  450. PROCEDURE Seek(file{1}: FileHandlePtr;
  451.                position{2}: LONGINT;
  452.                mode{3}: LONGINT): LONGINT;                       CODE -66;
  453. PROCEDURE DeleteFile(name{1}: STRPTR): BOOLEAN;                  CODE -72;
  454. PROCEDURE Rename(oldName{1},newName{2}: STRPTR): BOOLEAN;        CODE -78;
  455. PROCEDURE Lock(name{1}: STRPTR;
  456.                accessMode{2}: LONGINT): FileLockPtr;             CODE -84;
  457. PROCEDURE UnLock(lock{1}: FileLockPtr);                          CODE -90;
  458. PROCEDURE DupLock(lock{1}: FileLockPtr): FileLockPtr;            CODE -96;
  459. PROCEDURE Examine(lock{1}: FileLockPtr;
  460.                   infoBlock{2}: FileInfoBlockPtr): BOOLEAN;      CODE -102;
  461. PROCEDURE ExNext(lock{1}: FileLockPtr;
  462.                  infoBlock{2}: FileInfoBlockPtr): BOOLEAN;       CODE -108;
  463. PROCEDURE Info(lock{1}: FileLockPtr;
  464.                parameterBlock{2}: InfoDataPtr): BOOLEAN;         CODE -114;
  465. PROCEDURE CreateDir(name{1}: STRPTR): FileLockPtr;               CODE -120;
  466. PROCEDURE CurrentDir(lock{1}: FileLockPtr): FileLockPtr;         CODE -126;
  467. PROCEDURE IoErr(): LONGINT;                                      CODE -132;
  468. PROCEDURE CreateProc(name{1}: STRPTR;
  469.                      pri{2}: LONGINT;
  470.                      segment{3}: BPTR;
  471.                      stackSize{4}: LONGINT): ProcessPtr;         CODE -138;
  472. PROCEDURE Exit(returnCode{1}: LONGINT);                          CODE -144;
  473. PROCEDURE LoadSeg(name{1}: STRPTR): BPTR;                        CODE -150;
  474. PROCEDURE UnLoadSeg(segment{1}: BPTR);                           CODE -156;
  475. PROCEDURE GetPacket(wait{1}: LONGINT): DosPacketPtr;             CODE -162;
  476. PROCEDURE QueuePacket(packet{1}: DosPacketPtr): LONGINT;         CODE -168;
  477. PROCEDURE DeviceProc(name{1}: STRPTR): ProcessPtr;               CODE -174;
  478. PROCEDURE SetComment(name{1},comment{2}: STRPTR): BOOLEAN;       CODE -180;
  479. PROCEDURE SetProtection(name{1}:STRPTR;
  480.                         mask{2}:LONGSET): BOOLEAN;               CODE -186;
  481. PROCEDURE DateStamp(v{1}: DatePtr);                              CODE -192;
  482. PROCEDURE Delay(ticks{1}: LONGINT);                              CODE -198;
  483. PROCEDURE WaitForChar(file{1}: FileHandlePtr;
  484.                       timeout{2}: LONGINT): BOOLEAN;             CODE -204;
  485. PROCEDURE ParentDir(lock{1}: FileLockPtr): FileLockPtr;          CODE -210;
  486. PROCEDURE IsInteractive(file{1}: FileHandlePtr): BOOLEAN;        CODE -216;
  487. PROCEDURE Execute(commandString{1}: STRPTR;
  488.                   input{2}: FileHandlePtr;
  489.                   output{3}: FileHandlePtr): LONGINT;            CODE -222;
  490.  
  491. (*------  New ARP Routines:  ------*)
  492.  
  493. PROCEDURE AddDADevs(dalist{8}: DirectoryEntryPtr;
  494.                     select{0}: DirEntryTypeSet): LONGINT;        CODE -516;
  495. PROCEDURE AddDANode(data{8}: ADDRESS;
  496.                     dalist{9}: DirectoryEntryPtr;
  497.                     length{0}: LONGINT;
  498.                     id{1}: DirEntryTypeSet): DirectoryEntryPtr;  CODE -510;
  499. PROCEDURE AddResidentPrg(segment{1}: BPTR;
  500.                          name{8}: STRPTR): ResidentPrgNodePtr;   CODE -582;
  501. PROCEDURE ArpAlloc(size{0}: LONGINT): ADDRESS;                   CODE -384;
  502. PROCEDURE ArpAllocMem(size{0}: LONGINT;
  503.                       reqs{1}: MemReqSet): ADDRESS;              CODE -390;
  504. PROCEDURE ArpDupLock(lock{1}: FileLockPtr): FileLockPtr;         CODE -402;
  505. PROCEDURE ArpExit(returncode{0}: LONGINT;
  506.                   fault{2}: LONGINT);                            CODE -378;
  507. PROCEDURE ArpLock(name{1}: STRPTR;
  508.                   accessMode{2}: LONGINT): FileLockPtr;          CODE -408;
  509. PROCEDURE ArpOpen(name{1}: STRPTR;
  510.                   accessmode{2}: LONGINT): FileHandlePtr;        CODE -396;
  511. PROCEDURE Assign(name{8}: STRPTR;
  512.                  phys{9}: STRPTR): AssignRes;                    CODE -336;
  513. PROCEDURE ASyncRun(command{8}: STRPTR;
  514.                    args{9}: STRPTR;
  515.                    pcb{10}: ProcessCtrlBlkPtr): LONGINT;         CODE -546;
  516. PROCEDURE Atol(string{8}: STRPTR): LONGINT;                      CODE -258;
  517. PROCEDURE BaseName(pathname{8}: STRPTR): STRPTR;                 CODE -630;
  518. PROCEDURE BtoCStr(cstring{8}: STRPTR;
  519.                   bstr{0}: BSTR;
  520.                   maxlength{1}: LONGINT): LONGINT;               CODE -354;
  521. PROCEDURE CheckAbort(func{9}: PROC): LONGSET;                    CODE -270;
  522. PROCEDURE CheckBreak(mask{1}: LONGSET;
  523.                      func{9}: PROC): LONGSET;                    CODE -276;
  524. PROCEDURE CheckSumPrg(node{1}: ResidentPrgNodePtr): LONGCARD;    CODE -618;
  525. PROCEDURE CloseWindowSafely(window{8}: WindowPtr;
  526.                             morewindows{9}: BOOLEAN);            CODE -300;
  527. PROCEDURE CompareLock(lock1{0},lock2{1}: FileLockPtr): LockComp; CODE -456;
  528. PROCEDURE CreatePort(name{8}: STRPTR;
  529.                      priority{0}: Byte): MsgPortPtr;             CODE -306;
  530. PROCEDURE CreateTaskResList(): ArpResListPtr;                    CODE -468;
  531. PROCEDURE CtoBStr(cstring{8}: STRPTR;
  532.                   bstr{0}: BSTR;
  533.                   maxlength{1}: LONGINT): LONGINT;               CODE -360;
  534. PROCEDURE DeletePort(port{9}: MsgPortPtr);                       CODE -312;
  535. PROCEDURE DosAllocMem(size{0}: LONGINT): ADDRESS;                CODE -342;
  536. PROCEDURE DosFreeMem(memBlk{9}: ADDRESS);                        CODE -348;
  537. PROCEDURE EscapeString(string{8}: STRPTR): LONGINT;              CODE -264;
  538. PROCEDURE FileRequest(filereq{8}: FileRequesterPtr): ADDRESS;    CODE -294;
  539. PROCEDURE FindCLI(tasknum{0}: LONGINT): ProcessPtr;              CODE -420;
  540. PROCEDURE FindFirst(pat{0}: STRPTR;
  541.                     chain{8}: AnchorPathPtr): LONGINT;           CODE -438;
  542. PROCEDURE FindNext(chain{8}: AnchorPathPtr): LONGINT;            CODE -444;
  543. PROCEDURE FindTaskResList(): ArpResListPtr;                      CODE -462;
  544. PROCEDURE FPrintf(file{0}: FileHandlePtr;
  545.                   string{8}: STRPTR;
  546.                   args{9}: ADDRESS): LONGINT;                    CODE -234;
  547. PROCEDURE FreeAccess(tracker{9}: TrackedResPtr);                 CODE -498;
  548. PROCEDURE FreeAnchorChain(chain{8}: AnchorPathPtr);              CODE -450;
  549. PROCEDURE FreeDAList(dalist{9}: ADDRESS);                        CODE -504;
  550. PROCEDURE FreeResList(freelist{9}: ADDRESS);                     CODE -474;
  551. PROCEDURE FreeTaskResList(): BOOLEAN;                            CODE -372;
  552. PROCEDURE FreeTrackeItem(item{9}: TrackedResPtr);                CODE -480;
  553. PROCEDURE GADS(cmdLine{8}: ADDRESS;
  554.                cmdLen{0}: LONGINT;
  555.                help{9}: STRPTR;
  556.                argarray{10}: ADDRESS;
  557.                tplate{11}: STRPTR): LONGINT;                     CODE -252;
  558. PROCEDURE GetAccess(tracker{9}: TrackedResPtr): TrackedResPtr;   CODE -492;
  559. PROCEDURE GetDevInfo(devinfo{10}: DeviceListPtr): DeviceListPtr; CODE -366;
  560. PROCEDURE GetEnv(string{8}: STRPTR;
  561.                  buffer{9}: ADDRESS;
  562.                  size{0}: LONGINT): STRPTR;                      CODE -282;
  563. PROCEDURE GetTracker(id{9}: LONGINT): DefaultTrackerPtr;         CODE -486;
  564. PROCEDURE InitStdPacket(action{0}: LONGINT;
  565.                         args{8}: ADDRESS;
  566.                         packet{9}: ADDRESS;
  567.                         replyport{10}: MsgPortPtr);              CODE -324;
  568. PROCEDURE LDiv(dividend{0},divisor{1}: LONGINT): LONGINT;        CODE -606;
  569. PROCEDURE LMod(dividend{0},divisor{1}: LONGINT): LONGINT;        CODE -612;
  570. PROCEDURE LMult(num1{0},num2{1}: LONGINT): LONGINT;              CODE -600;
  571. PROCEDURE LoadPrg(name{1}: STRPTR): BPTR;                        CODE -552;
  572. PROCEDURE ObtainResidentPrg(name{8}: STRPTR): ResidentPrgNodePtr;CODE -576;
  573. PROCEDURE PathName(lock{0}: FileLockPtr;
  574.                    dest{8}: STRPTR;
  575.                    numberNames{1}: LONGINT): LONGINT;            CODE -330;
  576. PROCEDURE PatternMatch(pat{8}: STRPTR;
  577.                        str{9}: STRPTR): BOOLEAN;                 CODE -432;
  578. PROCEDURE PreParse(source{8}: STRPTR;
  579.                    dest{9}: STRPTR): BOOLEAN;                    CODE -558;
  580. PROCEDURE Printf(string{8}: STRPTR;
  581.                  args{9}: ADDRESS): LONGINT;                     CODE -228;
  582. PROCEDURE Puts(string{9}: STRPTR): LONGINT;                      CODE -240;
  583. PROCEDURE QSort(baseptr{8}: ADDRESS;
  584.                 regionsize{0}: LONGINT;
  585.                 bytesize{1}: LONGINT;
  586.                 userfunction{9}: PROC): BOOLEAN;                 CODE -426;
  587. PROCEDURE ReadLine(buffer{8}: ADDRESS): LONGINT;                 CODE -246;
  588. PROCEDURE ReleaseResidentPrg(segment{1}: ADDRESS):
  589.                                       ResidentPrgNodePtr;        CODE -636;
  590. PROCEDURE RemResidentPrg(name{8}: STRPTR): LONGCARD;             CODE -588;
  591. PROCEDURE RListAlloc(reslist{8}: ArpResListPtr;
  592.                      size{0}: LONGINT): ADDRESS;                 CODE -414;
  593. PROCEDURE SendPacket(action{0}: LONGINT;
  594.                      args{8}: ADDRESS;
  595.                      handler{9}: MsgPortPtr): LONGINT;           CODE -318;
  596. PROCEDURE SetEnv(string{8}: STRPTR;
  597.                  buffer{9}: ADDRESS): BOOLEAN;                   CODE -288;
  598. PROCEDURE StampToStr(datetime{8}: DateTimePtr): BOOLEAN;         CODE -564;
  599. PROCEDURE Strcmp(s1{8},s2{9}: STRPTR): LONGINT;                  CODE -522;
  600. PROCEDURE Strncmp(st{8},s2{9}: STRPTR;
  601.                   n{0}: LONGINT): LONGINT;                       CODE -528;
  602. PROCEDURE StrToStamp(datetime{8}: DateTimePtr): BOOLEAN;         CODE -570;
  603. PROCEDURE SyncRun(filename{8}: STRPTR;
  604.                   args{9}     : STRPTR;
  605.                   input{0}    : FileHandlePtr;
  606.                   output{1}   : FileHandlePtr): LONGINT;         CODE -540;
  607. PROCEDURE TackOn(pathname{8},filename{9}: STRPTR);               CODE -624;
  608. PROCEDURE ToUpper(old{0}: CHAR): CHAR;                           CODE -534;
  609. PROCEDURE UnLoadPrg(segment{1}: BPTR);                           CODE -594;
  610.  
  611. END ARP.
  612.